集合

之前看到的列表和字符串都是一种有序序列，而集合 set 是一种无序的序列。

因为集合是无序的，所以当集合中存在两个同样的元素的时候，Python只会保存其中的一个（唯一性）；同时为了确保其中不包含同样的元素，集合中放入的元素只能是不可变的对象（确定性）。

集合生成

可以用set()函数来显示的生成空集合：

In [1]:
a = set()
type(a)
Out[1]:
set

也可以使用一个列表来初始化一个集合：

In [2]:
a = set([1, 2, 3, 1])
a
Out[2]:
{1, 2, 3}

集合会自动去除重复元素 1。

可以看到，集合中的元素是用大括号{}包含起来的，这意味着可以用{}的形式来创建集合：

In [3]:
a = {1, 2, 3, 1}
a
Out[3]:
{1, 2, 3}

但是创建空集合的时候只能用set来创建，因为在Python中{}创建的是一个空的字典：

In [4]:
s = {}
type(s)
Out[4]:
dict

集合操作

假设有这样两个集合：

In [5]:
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

并

两个集合的并，返回包含两个集合所有元素的集合（去除重复）。

可以用方法 a.union(b) 或者操作 a | b 实现。

In [6]:
a.union(b)
Out[6]:
{1, 2, 3, 4, 5, 6}
In [7]:
b.union(a)
Out[7]:
{1, 2, 3, 4, 5, 6}
In [8]:
a | b
Out[8]:
{1, 2, 3, 4, 5, 6}

交

两个集合的交，返回包含两个集合共有元素的集合。

可以用方法 a.intersection(b) 或者操作 a & b 实现。

In [9]:
a.intersection(b)
Out[9]:
{3, 4}
In [10]:
b.intersection(a)
Out[10]:
{3, 4}
In [11]:
a & b
Out[11]:
{3, 4}
In [12]:
print(a & b)

set([3, 4])

注意：一般使用print打印set的结果与表示方法并不一致。

差

a 和 b 的差集，返回只在 a 不在 b 的元素组成的集合。

可以用方法 a.difference(b) 或者操作 a - b 实现。

In [13]:
a.difference(b)
Out[13]:
{1, 2}
In [14]:
a - b
Out[14]:
{1, 2}

注意，a - b 与 b - a并不一样，b - a 返回的是返回 b 不在 a 的元素组成的集合：

In [15]:
b.difference(a)
Out[15]:
{5, 6}
In [16]:
b - a
Out[16]:
{5, 6}

对称差

a 和b 的对称差集，返回在 a 或在 b 中，但是不同时在 a 和 b 中的元素组成的集合。

可以用方法 a.symmetric_difference(b) 或者操作 a ^ b 实现（异或操作符）。

In [17]:
a.symmetric_difference(b)
Out[17]:
{1, 2, 5, 6}
In [18]:
b.symmetric_difference(a)
Out[18]:
{1, 2, 5, 6}
In [19]:
a ^ b
Out[19]:
{1, 2, 5, 6}

包含关系

假设现在有这样两个集合：

In [20]:
a = {1, 2, 3}
b = {1, 2}

要判断 b 是不是 a 的子集，可以用 b.issubset(a) 方法，或者更简单的用操作 b <= a ：

In [21]:
b.issubset(a)
Out[21]:
True
In [22]:
b <= a
Out[22]:
True

与之对应，也可以用 a.issuperset(b) 或者 a >= b 来判断：

In [23]:
a.issuperset(b)
Out[23]:
True
In [24]:
a >= b
Out[24]:
True

方法只能用来测试子集，但是操作符可以用来判断真子集：

In [25]:
a <= a
Out[25]:
True

自己不是自己的真子集：

In [26]:
a < a
Out[26]:
False

集合方法

add 方法向集合添加单个元素

跟列表的 append 方法类似，用来向集合添加单个元素。

s.add(a)

将元素 a 加入集合 s 中。

In [27]:
t = {1, 2, 3}
t.add(5)
t
Out[27]:
{1, 2, 3, 5}

如果添加的是已有元素，集合不改变：

In [28]:
t.add(3)
t
Out[28]:
{1, 2, 3, 5}

update 方法向集合添加多个元素

跟列表的extend方法类似，用来向集合添加多个元素。

s.update(seq)

将seq中的元素添加到s中。

In [29]:
t.update([5, 6, 7])
t
Out[29]:
{1, 2, 3, 5, 6, 7}

remove 方法移除单个元素

s.remove(ob)

从集合s中移除元素ob，如果不存在会报错。

In [30]:
t.remove(1)
t
Out[30]:
{2, 3, 5, 6, 7}
In [31]:
t.remove(10)

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-31-3bc25c5e1ff4> in <module>()
----> 1 t.remove(10)

KeyError: 10

pop方法弹出元素

由于集合没有顺序，不能像列表一样按照位置弹出元素，所以pop 方法删除并返回集合中任意一个元素，如果集合中没有元素会报错。

In [32]:
t.pop()
Out[32]:
{3, 5, 6, 7}
In [33]:
print t

set([3, 5, 6, 7])
In [34]:
s = set()
# 报错
s.pop()

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-34-9f9e06c962e6> in <module>()
      1 s = set()
      2 # 报错
----> 3 s.pop()

KeyError: 'pop from an empty set'

discard 方法

作用与 remove 一样，但是当元素在集合中不存在的时候不会报错。

In [35]:
t.discard(3)
In [36]:
t
Out[36]:
{5, 6, 7}

不存在的元素不会报错：

In [37]:
t.discard(20)
In [38]:
t
Out[38]:
{5, 6, 7}

difference_update方法

a.difference_update(b)

从a中去除所有属于b的元素：